package com.example.administrator.pathdemo;

import android.animation.ValueAnimator;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.PathMeasure;
import android.graphics.PointF;
import android.os.Build;
import android.os.Handler;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.annotation.RequiresApi;
import android.util.AttributeSet;
import android.util.Log;
import android.view.View;
import android.view.animation.DecelerateInterpolator;
import android.view.animation.LinearInterpolator;

import java.util.Timer;
import java.util.TimerTask;

/**
 * Created by Administrator on 2018\3\15 0015.
 */

public class PathDemo extends View {


    private static final int LINEWIDTH = 5;
    private static final int POINTWIDTH = 10;


    private float[] mCurrentPosition = new float[2];
    private Matrix mMatrix;
    private float currentValue = 0;     // 用于纪录当前的位置,取值范围[0,1]映射Path的整个长度

    private float[] pos;                // 当前点的实际位置
    private float[] tan;                // 当前点的tangent值,用于计算图片所需旋转的角度


    private float mPreX = 268, mPreY = 96;
    private float currentPos = 0;





    Handler handler=new Handler();
    Runnable runnable=new Runnable() {
        @Override
        public void run() {
//            startAnim(2000L);
//            count++;
//
//            Log.e("TAG","count:"+count);
//            //要做的事情
//            handler.removeCallbacksAndMessages(null);
//            handler.postDelayed(this, 2000);


//            PathEffect pe = new DashPathEffect(new float[]{d, len - d}, 0);
//            mPaint.setPathEffect(pe);
//            invalidate();

        }
    };



    Path mPath = new Path();
    private Paint mPaint;
    private Paint mPointPaint;


    Path mPath1 = new Path();
    private Paint mPaint1;



    private PathMeasure mPathMeasure;
    private Bitmap mBitmap;
    private boolean isDrawFire = true;
    private ValueAnimator valueAnimator;


    public PathDemo(@NonNull Context context) {
        super(context);
        initPaint(context);
    }

    public PathDemo(@NonNull Context context, @Nullable AttributeSet attrs) {
        super(context, attrs);
        initPaint(context);
    }

    public PathDemo(@NonNull Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        initPaint(context);
    }

    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
    public PathDemo(@NonNull Context context, @Nullable AttributeSet attrs, int defStyleAttr, int defStyleRes) {
        super(context, attrs, defStyleAttr, defStyleRes);
        initPaint(context);
    }


    private void initPaint(Context context) {

        pos = new float[2];
        tan = new float[2];


        mPaint = new Paint();
        mPaint.setColor(Color.BLACK);
        mPaint.setStrokeWidth(8);
        mPaint.setStyle(Paint.Style.STROKE);
        mPaint.setTextSize(60);

        mPaint1 = new Paint();
        mPaint1.setColor(Color.RED);
        mPaint1.setStrokeWidth(15);
        mPaint1.setStyle(Paint.Style.STROKE);
        mPaint1.setTextSize(60);

        mPointPaint = new Paint();
        mPointPaint.setColor(Color.RED);
        mPointPaint.setStrokeWidth(15);
        mPointPaint.setStyle(Paint.Style.STROKE);
        mPointPaint.setTextSize(60);

        mCurrentPosition = new float[2];

        BitmapFactory.Options options = new BitmapFactory.Options();
        options.inSampleSize = 10;       // 缩放图片
        mBitmap = BitmapFactory.decodeResource(context.getResources(), R.mipmap.fire, options);

        mMatrix = new Matrix();

    }







    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);

        drawTest(canvas);

        currentValue += 0.005;                                  // 计算当前的位置在总长度上的比例[0,1]
        if (currentValue >= 1) {
            currentValue = 0;
        }

//        mPathMeasure.getPosTan(mPathMeasure.getLength(), pos, tan);


        drawFire(canvas);



//
//        // 绘制对应目标
//        canvas.drawCircle(268, 96, 10, mPaint);
//
//        // 绘制对应目标
//        if (mCurrentPosition[0]!=0&&mCurrentPosition[1] != 0){
//
//            canvas.drawCircle(mCurrentPosition[0], mCurrentPosition[1], 10, mPaint);
//        }
        canvas.drawPath(mPath1,mPaint1);



        Path dstPath = new Path();

        mPathMeasure.getSegment(0f,currentPos,dstPath,true);

        canvas.drawPath(dstPath,mPointPaint);

    }

    private void drawFire(Canvas canvas) {

        // 绘制箭头
        canvas.drawBitmap(mBitmap, mMatrix, mPaint1);


        mMatrix.reset();                                                        // 重置Matrix
        float degrees = (float) (Math.atan2(tan[1], tan[0]) * 180.0 / Math.PI); // 计算图片旋转角度

        mMatrix.postRotate(degrees, mBitmap.getWidth() / 2, mBitmap.getHeight() / 2);   // 旋转图片

        if (pos[0]==0&&pos[1]==0){
            pos[0] = 268;
            pos[1] = 96;

            mMatrix.postTranslate(pos[0] - mBitmap.getWidth() / 2, pos[1] - mBitmap.getHeight() / 2);   // 将图片绘制中心调整到与当前点重合
        } else {

            mMatrix.postTranslate(pos[0] - mBitmap.getWidth() / 2, pos[1] - mBitmap.getHeight() / 2);   // 将图片绘制中心调整到与当前点重合



        }

    }

    private boolean isDrawFire() {

        return isDrawFire;
    }


    private void drawTest(Canvas canvas){

        mPaint.setStrokeWidth(LINEWIDTH);
        mPaint.setColor(Color.BLACK);
        // 重置路径
        mPath.reset();
        mPath.moveTo(268, 96);// 起点
        mPath.lineTo(203,122);
        mPath.quadTo(167,143,196,191);
        mPath.lineTo(119,270);
        mPath.quadTo(104,315,21,348);
        mPath.quadTo(8,369,33,373);


        mPath.quadTo(63,357,122,336);
        mPath.quadTo(171,329,150,281);
        mPath.lineTo(234,174);
        mPath.quadTo(213,155,223,145);
        mPath.lineTo(263,154);
        mPath.quadTo(272,170,249,197);
        mPath.quadTo(240,212,261,215);
        mPath.lineTo(470,145);
        mPath.quadTo(487,130,470,116);
        mPath.quadTo(451,109,423,108);
        mPath.quadTo(423,108,401,118);
        mPath.close();


        mPathMeasure = new PathMeasure(mPath,true);

        canvas.drawPath(mPath,mPaint);
    }


    public void startAnim(Long duration){

//
//        mPaint1.setStrokeWidth(15);
//
//        if (count%2==0){
//            mPaint1.setColor(Color.RED);
//        } else {
//            mPaint1.setColor(Color.GREEN);
//        }
//
//
//        mPath1.reset();
//        mPath1.moveTo(268, 96);// 起点
//        mPath1.lineTo(203,122);
//        mPath1.quadTo(167,143,196,191);
//        mPath1.lineTo(119,270);
//        mPath1.quadTo(104,315,21,348);
//        mPath1.quadTo(8,369,33,373);
//
//
//        mPathMeasure = new PathMeasure(mPath1, true);


        valueAnimator = ValueAnimator.ofFloat(0, mPathMeasure.getLength());
        Log.i("TAG", "measure length = " + mPathMeasure.getLength());
        valueAnimator.setDuration(duration);
        // 匀速插值器
        valueAnimator.setInterpolator(new LinearInterpolator());
        valueAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {

            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                float value = (Float) animation.getAnimatedValue();
                // 获取当前点坐标封装到pos
//                mPathMeasure.getPosTan(value, mCurrentPosition, null);
                mPathMeasure.getPosTan(value, pos, tan);
                currentPos = value;
//                mPointPath.quadTo(mPreX,mPreY,pos[0],pos[1]);
//                mPreX = pos[0];
//                mPreY = pos[1];
                Log.e("TAG","当前坐标："+value);
                postInvalidate();
            }
        });
        valueAnimator.start();


        invalidate();

//        handler.postDelayed(runnable, 2000);//每两秒执行一次runnable。

    }


    public void stopAnim(){

        valueAnimator.cancel();

    }

//
//    private void drawPoints(Canvas canvas) {
//        mPaint.setStrokeWidth(POINTWIDTH);
//        for (int i = 0; i < mPoints.size(); i++) {
//            canvas.drawPoint(mPoints.get(i).x, mPoints.get(i).y, mPaint);
//        }
//    }

//    /** 画穿越原始点的折线 */
//    private void drawCrossPointsBrokenLine(Canvas canvas) {
//        mPaint.setStrokeWidth(LINEWIDTH);
//        mPaint.setColor(Color.RED);
//        // 重置路径
//        mPath.reset();
//        // 画穿越原始点的折线
//        mPath.moveTo(mPoints.get(0).x, mPoints.get(0).y);
//        for (int i = 0; i < mPoints.size(); i++) {
//            mPath.lineTo(mPoints.get(i).x, mPoints.get(i).y);
//        }
//        canvas.drawPath(mPath, mPaint);
//    }
//
//    /** 画中间点 */
//    private void drawMidPoints(Canvas canvas) {
//        mPaint.setStrokeWidth(POINTWIDTH);
//        mPaint.setColor(Color.BLUE);
//        for (int i = 0; i < mMidPoints.size(); i++) {
//            canvas.drawPoint(mMidPoints.get(i).x, mMidPoints.get(i).y, mPaint);
//        }
//    }
//
//    /** 画中间点的中间点 */
//    private void drawMidMidPoints(Canvas canvas) {
//        mPaint.setColor(Color.YELLOW);
//        for (int i = 0; i < mMidMidPoints.size(); i++) {
//            canvas.drawPoint(mMidMidPoints.get(i).x, mMidMidPoints.get(i).y, mPaint);
//        }
//
//    }
//
//    /** 画控制点 */
//    private void drawControlPoints(Canvas canvas) {
//        mPaint.setColor(Color.GRAY);
//        // 画控制点
//        for (int i = 0; i < mControlPoints.size(); i++) {
//            canvas.drawPoint(mControlPoints.get(i).x, mControlPoints.get(i).y, mPaint);
//        }
//    }
//
//
//    private void drawBezier(Canvas canvas) {
//        mPaint.setStrokeWidth(LINEWIDTH);
//        mPaint.setColor(Color.BLACK);
//        // 重置路径
//        mPath.reset();
//        for (int i = 0; i < mPoints.size(); i++){
//            if (i == 0){// 第一条为二阶贝塞尔
//                mPath.moveTo(mPoints.get(i).x, mPoints.get(i).y);// 起点
//                mPath.quadTo(mControlPoints.get(i).x, mControlPoints.get(i).y,// 控制点
//                        mPoints.get(i + 1).x,mPoints.get(i + 1).y);
//            }else if(i < mPoints.size() - 2){// 三阶贝塞尔
//                mPath.cubicTo(mControlPoints.get(2*i-1).x,mControlPoints.get(2*i-1).y,// 控制点
//                        mControlPoints.get(2*i).x,mControlPoints.get(2*i).y,// 控制点
//                        mPoints.get(i+1).x,mPoints.get(i+1).y);// 终点
//            }else if(i == mPoints.size() - 2){// 最后一条为二阶贝塞尔
////                mPath.moveTo(mPoints.get(i).x, mPoints.get(i).y);// 起点
////                mPath.quadTo(mControlPoints.get(mControlPoints.size()-1).x,mControlPoints.get(mControlPoints.size()-1).y,
////                        mPoints.get(i+1).x,mPoints.get(i+1).y);// 终点
//                mPath.close();
//            }
//
//
//        }
//        canvas.drawPath(mPath,mPaint);
//    }


}
